;; New event definitions
(define-map course-ratings
    { course-id: uint, student: principal }
    { rating: uint, timestamp: uint }
)

(define-map course-rating-stats
    { course-id: uint }
    {
        total-ratings: uint,
        sum-ratings: uint,
        average-rating: uint
    }
)

;; New functions for rating system
(define-public (rate-course (course-id uint) (rating uint))
    (let
        (
            (enrollment (unwrap! (map-get? student-enrollments 
                { student: tx-sender, course-id: course-id }) 
                ERR-NOT-ENROLLED))
            (current-stats (default-to 
                { total-ratings: u0, sum-ratings: u0, average-rating: u0 }
                (map-get? course-rating-stats { course-id: course-id })))
        )
        
        ;; Verify rating is between 1 and 5
        (asserts! (and (>= rating u1) (<= rating u5)) ERR-INVALID-RATING)
        
        ;; Store individual rating
        (map-set course-ratings
            { course-id: course-id, student: tx-sender }
            { rating: rating, timestamp: block-height }
        )
        
        ;; Update rating statistics
        (map-set course-rating-stats
            { course-id: course-id }
            {
                total-ratings: (+ (get total-ratings current-stats) u1),
                sum-ratings: (+ (get sum-ratings current-stats) rating),
                average-rating: (/ 
                    (+ (get sum-ratings current-stats) rating)
                    (+ (get total-ratings current-stats) u1)
                )
            }
        )
        
        ;; Emit rating event
        (print { type: "course-rated", course-id: course-id, rating: rating })
        (ok true)
    )
)

;; Enhanced enrollment function with event emission
(define-public (enroll-in-course (course-id uint))
    (let
        (
            (course-details (unwrap! (map-get? course-registry { course-id: course-id }) 
                ERR-COURSE-NOT-FOUND))
            (revenue-distribution (calculate-revenue-distribution 
                (get course-price-stx course-details)))
        )
        ;; Existing enrollment logic...
        
        ;; Emit enrollment event
        (print {
            type: "enrollment",
            course-id: course-id,
            student: tx-sender,
            amount: (get course-price-stx course-details)
        })
        
        (ok true)
    )
)

;; Batch operations support
(define-public (batch-register-courses (course-data (list 200 {
    course-id: uint,
    price: uint,
    revenue-percentage: uint,
    syllabus: (string-utf8 256),
    subscription: bool,
    period: uint
})))
    (fold check-and-register course-data (ok true))
)

(define-private (check-and-register (course {
    course-id: uint,
    price: uint,
    revenue-percentage: uint,
    syllabus: (string-utf8 256),
    subscription: bool,
    period: uint
}) (previous-result (response bool uint)))
    (match previous-result
        success (register-course 
            (get course-id course)
            (get price course)
            (get revenue-percentage course)
            (get syllabus course)
            (get subscription course)
            (get period course))
        error error
    )
)

;; Test cases
(test-course-rating-system
    (begin
        ;; Test valid rating
        (assert-ok (rate-course u1 u5))
        
        ;; Test invalid rating
        (assert-err (rate-course u1 u6) ERR-INVALID-RATING)
        
        ;; Test rating without enrollment
        (assert-err (as-contract (rate-course u2 u4)) ERR-NOT-ENROLLED)
    )
)